// 工具函数

/**
 * 格式化日期
 * @param {Date} date - 日期对象
 * @returns {string} 格式化后的日期字符串 (YYYY-MM-DD)
 */
export function formatDate(date) {
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  return `${year}-${month}-${day}`;
}

/**
 * 获取当前日期
 * @returns {string} 当前日期字符串 (YYYY-MM-DD)
 */
export function getCurrentDate() {
  return formatDate(new Date());
}

/**
 * 获取指定天数后的日期
 * @param {number} days - 天数
 * @returns {string} 日期字符串 (YYYY-MM-DD)
 */
export function getDateAfterDays(days) {
  const date = new Date();
  date.setDate(date.getDate() + days);
  return formatDate(date);
}

/**
 * 计算两个日期之间的天数差
 * @param {string} date1 - 日期字符串 (YYYY-MM-DD)
 * @param {string} date2 - 日期字符串 (YYYY-MM-DD)
 * @returns {number} 天数差
 */
export function getDateDiff(date1, date2) {
  const d1 = new Date(date1);
  const d2 = new Date(date2);
  const diffTime = Math.abs(d2 - d1);
  return Math.ceil(diffTime / (1000 * 60 * 60 * 24));
}

/**
 * 格式化时间
 * @param {string} time - 时间字符串 (HH:MM)
 * @returns {string} 格式化后的时间字符串 (HH:MM)
 */
export function formatTime(time) {
  const [hours, minutes] = time.split(':');
  return `${String(hours).padStart(2, '0')}:${String(minutes).padStart(2, '0')}`;
}

/**
 * 生成时间槽
 * @param {string} startTime - 开始时间 (HH:MM)
 * @param {string} endTime - 结束时间 (HH:MM)
 * @param {number} interval - 时间间隔（分钟）
 * @returns {Array} 时间槽数组
 */
export function generateTimeSlots(startTime, endTime, interval = 60) {
  const slots = [];
  let currentTime = new Date(`2000-01-01T${startTime}:00`);
  const endDateTime = new Date(`2000-01-01T${endTime}:00`);
  
  while (currentTime < endDateTime) {
    const timeString = formatTime(`${currentTime.getHours()}:${currentTime.getMinutes()}`);
    slots.push({
      time: timeString,
      isFree: true
    });
    
    currentTime.setMinutes(currentTime.getMinutes() + interval);
  }
  
  return slots;
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, delay) {
  let timeoutId;
  return function (...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => func.apply(this, args), delay);
  };
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Function} 节流后的函数
 */
export function throttle(func, delay) {
  let lastExecTime = 0;
  return function (...args) {
    const currentTime = Date.now();
    if (currentTime - lastExecTime >= delay) {
      func.apply(this, args);
      lastExecTime = currentTime;
    }
  };
}

/**
 * 深拷贝对象
 * @param {Object} obj - 要拷贝的对象
 * @returns {Object} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') {
    return obj;
  }
  
  if (obj instanceof Date) {
    return new Date(obj.getTime());
  }
  
  if (obj instanceof Array) {
    return obj.map(item => deepClone(item));
  }
  
  if (typeof obj === 'object') {
    const clonedObj = {};
    for (let key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key]);
      }
    }
    return clonedObj;
  }
}

export default {
  formatDate,
  getCurrentDate,
  getDateAfterDays,
  getDateDiff,
  formatTime,
  generateTimeSlots,
  debounce,
  throttle,
  deepClone
};